home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / exampleCode / opengl / GLUT / lib / glut / glutint.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-11  |  18.0 KB  |  473 lines
  1. #ifndef __glutint_h__
  2. #define __glutint_h__
  3.  
  4. /* Copyright (c) Mark J. Kilgard, 1994. */
  5.  
  6. /* This program is freely distributable without licensing fees 
  7.    and is provided without guarantee or warrantee expressed or 
  8.    implied. This program is -not- in the public domain. */
  9.  
  10. #ifdef __sgi
  11. #define SUPPORT_FORTRAN
  12. #endif
  13. #include <X11/Xlib.h>
  14. #include <GL/glx.h>
  15. #include <GL/glut.h>
  16. #ifdef __vms
  17. struct timeval {
  18.   __int64 val;
  19. };
  20. extern int sys$gettim(struct timeval *);
  21. #else
  22. #include <sys/types.h>
  23. #include <sys/time.h>
  24. #endif
  25. #if defined(__vms)
  26.  
  27. /* One TICK on VMS is 100 nanoseconds; 0.1 microseconds or
  28.    0.0001 milliseconds. This means that there are 0.01
  29.    ticks/ns, 10 ticks/us, 10,000 ticks/ms and 10,000,000
  30.    ticks/second. */
  31.  
  32. #define TICKS_PER_MILLISECOND 10000
  33. #define TICKS_PER_SECOND      10000000
  34.  
  35. #define GETTIMEOFDAY(_x) (void) sys$gettim (_x);
  36.  
  37. #define ADD_TIME(dest, src1, src2) { \
  38.   (dest).val = (src1).val + (src2).val; \
  39. }
  40.  
  41. #define TIMEDELTA(dest, src1, src2) { \
  42.   (dest).val = (src1).val - (src2).val; \
  43. }
  44.  
  45. #define IS_AFTER(t1, t2) ((t2).val > (t1).val)
  46.  
  47. #define IS_AT_OR_AFTER(t1, t2) ((t2).val >= (t1).val)
  48.  
  49. #else
  50. #if defined(SVR4) && !defined(sun)  /* Sun claims SVR4, but wants 2 args. */
  51. #define GETTIMEOFDAY(_x) gettimeofday(_x)
  52. #else
  53. #define GETTIMEOFDAY(_x) gettimeofday(_x, (struct timezone*) NULL)
  54. #endif
  55. #define ADD_TIME(dest, src1, src2) { \
  56.   if(((dest).tv_usec = \
  57.     (src1).tv_usec + (src2).tv_usec) >= 1000000) { \
  58.     (dest).tv_usec -= 1000000; \
  59.     (dest).tv_sec = (src1).tv_sec + (src2).tv_sec + 1; \
  60.   } else { \
  61.     (dest).tv_sec = (src1).tv_sec + (src2).tv_sec; \
  62.     if(((dest).tv_sec >= 1) && (((dest).tv_usec <0))) { \
  63.       (dest).tv_sec --;(dest).tv_usec += 1000000; \
  64.     } \
  65.   } \
  66. }
  67. #define TIMEDELTA(dest, src1, src2) { \
  68.   if(((dest).tv_usec = (src1).tv_usec - (src2).tv_usec) < 0) { \
  69.     (dest).tv_usec += 1000000; \
  70.     (dest).tv_sec = (src1).tv_sec - (src2).tv_sec - 1; \
  71.   } else { \
  72.      (dest).tv_sec = (src1).tv_sec - (src2).tv_sec; \
  73.   } \
  74. }
  75. #define IS_AFTER(t1, t2) \
  76.   (((t2).tv_sec > (t1).tv_sec) || \
  77.   (((t2).tv_sec == (t1).tv_sec) && \
  78.   ((t2).tv_usec > (t1).tv_usec)))
  79. #define IS_AT_OR_AFTER(t1, t2) \
  80.   (((t2).tv_sec > (t1).tv_sec) || \
  81.   (((t2).tv_sec == (t1).tv_sec) && \
  82.   ((t2).tv_usec >= (t1).tv_usec)))
  83. #endif
  84. #define GLUT_WIND_IS_RGB(x)         (((x) & GLUT_INDEX) == 0)
  85. #define GLUT_WIND_IS_INDEX(x)       (((x) & GLUT_INDEX) != 0)
  86. #define GLUT_WIND_IS_SINGLE(x)      (((x) & GLUT_DOUBLE) == 0)
  87. #define GLUT_WIND_IS_DOUBLE(x)      (((x) & GLUT_DOUBLE) != 0)
  88. #define GLUT_WIND_HAS_ACCUM(x)      (((x) & GLUT_ACCUM) != 0)
  89. #define GLUT_WIND_HAS_ALPHA(x)      (((x) & GLUT_ALPHA) != 0)
  90. #define GLUT_WIND_HAS_DEPTH(x)      (((x) & GLUT_DEPTH) != 0)
  91. #define GLUT_WIND_HAS_STENCIL(x)    (((x) & GLUT_STENCIL) != 0)
  92. #define GLUT_WIND_IS_MULTISAMPLE(x) (((x) & GLUT_MULTISAMPLE) != 0)
  93. #define GLUT_WIND_IS_STEREO(x)      (((x) & GLUT_STEREO) != 0)
  94. #define GLUT_WIND_IS_LUMINANCE(x)   (((x) & GLUT_LUMINANCE) != 0)
  95. #define GLUT_MAP_WORK               (1 << 0)
  96. #define GLUT_EVENT_MASK_WORK        (1 << 1)
  97. #define GLUT_REDISPLAY_WORK         (1 << 2)
  98. #define GLUT_CONFIGURE_WORK         (1 << 3)
  99. #define GLUT_COLORMAP_WORK          (1 << 4)
  100. #define GLUT_DEVICE_MASK_WORK        (1 << 5)
  101. #define GLUT_FINISH_WORK        (1 << 6)
  102. #define GLUT_DEBUG_WORK            (1 << 7)
  103. #define GLUT_DUMMY_WORK            (1 << 8)
  104. #define GLUT_FULL_SCREEN_WORK       (1 << 9)
  105. #define GLUT_OVERLAY_REDISPLAY_WORK (1 << 10)
  106. /* GLUT callback function types */
  107. typedef void (*GLUTdisplayCB) (void);
  108. typedef void (*GLUTreshapeCB) (int, int);
  109. typedef void (*GLUTkeyboardCB) (unsigned char, int, int);
  110. typedef void (*GLUTmouseCB) (int, int, int, int);
  111. typedef void (*GLUTmotionCB) (int, int);
  112. typedef void (*GLUTpassiveCB) (int, int);
  113. typedef void (*GLUTentryCB) (int);
  114. typedef void (*GLUTvisibilityCB) (int);
  115. typedef void (*GLUTidleCB) (void);
  116. typedef void (*GLUTtimerCB) (int);
  117. typedef void (*GLUTmenuStateCB) (int);  /* DEPRICATED. */
  118. typedef void (*GLUTmenuStatusCB) (int, int, int);
  119. typedef void (*GLUTselectCB) (int);
  120. typedef void (*GLUTspecialCB) (int, int, int);
  121. typedef void (*GLUTspaceMotionCB) (int, int, int);
  122. typedef void (*GLUTspaceRotateCB) (int, int, int);
  123. typedef void (*GLUTspaceButtonCB) (int, int);
  124. typedef void (*GLUTdialsCB) (int, int);
  125. typedef void (*GLUTbuttonBoxCB) (int, int);
  126. typedef void (*GLUTtabletMotionCB) (int, int);
  127. typedef void (*GLUTtabletButtonCB) (int, int, int, int);
  128. #ifdef SUPPORT_FORTRAN
  129. typedef void (*GLUTdisplayFCB) (void);
  130. typedef void (*GLUTreshapeFCB) (int *, int *);
  131. /* NOTE the pressed key is int, not unsigned char for Fortran! */
  132. typedef void (*GLUTkeyboardFCB) (int *, int *, int *);
  133. typedef void (*GLUTmouseFCB) (int *, int *, int *, int *);
  134. typedef void (*GLUTmotionFCB) (int *, int *);
  135. typedef void (*GLUTpassiveFCB) (int *, int *);
  136. typedef void (*GLUTentryFCB) (int *);
  137. typedef void (*GLUTvisibilityFCB) (int *);
  138. typedef void (*GLUTidleFCB) (void);
  139. typedef void (*GLUTtimerFCB) (int *);
  140. typedef void (*GLUTmenuStateFCB) (int *);  /* DEPRICATED. */
  141. typedef void (*GLUTmenuStatusFCB) (int *, int *, int *);
  142. typedef void (*GLUTselectFCB) (int *);
  143. typedef void (*GLUTspecialFCB) (int *, int *, int *);
  144. typedef void (*GLUTspaceMotionFCB) (int *, int *, int *);
  145. typedef void (*GLUTspaceRotateFCB) (int *, int *, int *);
  146. typedef void (*GLUTspaceButtonFCB) (int *, int *);
  147. typedef void (*GLUTdialsFCB) (int *, int *);
  148. typedef void (*GLUTbuttonBoxFCB) (int *, int *);
  149. typedef void (*GLUTtabletMotionFCB) (int *, int *);
  150. typedef void (*GLUTtabletButtonFCB) (int *, int *, int *, int *);
  151. #endif
  152. typedef struct _GLUTcolorcell GLUTcolorcell;
  153. struct _GLUTcolorcell {
  154.   /* GLUT_RED, GLUT_GREEN, GLUT_BLUE */
  155.   GLfloat component[3];
  156. };
  157. typedef struct _GLUTcolormap GLUTcolormap;
  158. struct _GLUTcolormap {
  159.   Visual *visual;       /* visual of the colormap */
  160.   Colormap cmap;        /* X colormap ID */
  161.   int refcnt;           /* number of windows using colormap */
  162.   int size;             /* number of cells in colormap */
  163.   int transparent;      /* transparent pixel, or -1 if opaque */
  164.   GLUTcolorcell *cells; /* array of cells */
  165.   GLUTcolormap *next;   /* next colormap in list */
  166. };
  167. typedef struct _GLUTwindow GLUTwindow;
  168. typedef struct _GLUToverlay GLUToverlay;
  169. struct _GLUTwindow {
  170.   int num;              /* small integer window id (0-based) */
  171.   /* Window system related state. */
  172.   Window win;           /* X window for GLUT window */
  173.   GLXContext ctx;       /* OpenGL context GLUT glut window */
  174.   XVisualInfo *vis;     /* visual for window */
  175.   Colormap cmap;        /* RGB colormap for window; None if CI */
  176.   GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
  177.   GLUToverlay *overlay; /* overlay; NULL if no overlay */
  178.   Window renderWin;     /* X window for rendering (might be
  179.                            overlay) */
  180.   GLXContext renderCtx; /* OpenGL context for rendering (might
  181.                            be overlay) */
  182.   /* GLUT settable or visible window state. */
  183.   int width;            /* window width in pixels */
  184.   int height;           /* window height in pixels */
  185.   int cursor;           /* cursor name */
  186.   int visState;         /* visibility state (-1 is unknown) */
  187.   int shownState;       /* if window mapped */
  188.   int entryState;       /* entry state (-1 is unknown) */
  189.   int damaged;          /* is layer damaged by expose? */
  190. #define GLUT_MAX_MENUS              3
  191.  
  192.   int menu[GLUT_MAX_MENUS];  /* attatched menu nums */
  193.   /* Window relationship state. */
  194.   GLUTwindow *parent;   /* parent window */
  195.   GLUTwindow *children; /* list of children */
  196.   GLUTwindow *siblings; /* list of siblings */
  197.   /* Misc. non-API visible (hidden) state. */
  198.   Bool fakeSingle;      /* faking single buffer with double */
  199.   Bool forceReshape;    /* force reshape before display */
  200.   Bool isDirect;        /* if direct context */
  201.   long eventMask;       /* mask of X events selected for */
  202.   int buttonUses;       /* number of button uses, ref cnt */
  203.   int tabletPos[2];     /* tablet position (-1 is invalid) */
  204.   /* Work list related state. */
  205.   unsigned int workMask;  /* mask of window work to be done */
  206.   GLUTwindow *prevWorkWin;  /* link list of windows to work on */
  207.   Bool desiredMapState; /* how to mapped window if on map work
  208.                            list */
  209.   int desiredConfMask;  /* mask of desired window configuration 
  210.                          */
  211.   int desiredX;         /* desired X location */
  212.   int desiredY;         /* desired Y location */
  213.   int desiredWidth;     /* desired window width */
  214.   int desiredHeight;    /* desired window height */
  215.   int desiredStack;     /* desired window stack */
  216.   /* Callbacks */
  217.   GLUTdisplayCB display;  /* redraw callback */
  218.   GLUTreshapeCB reshape;  /* resize callback (width,height) */
  219.   GLUTmouseCB mouse;    /* mouse callback (button,state,x,y) */
  220.   GLUTmotionCB motion;  /* motion callback (x,y) */
  221.   GLUTpassiveCB passive;  /* passive motion callback (x,y) */
  222.   GLUTentryCB entry;    /* window entry/exit callback (state) */
  223.   GLUTkeyboardCB keyboard;  /* keyboard callback (ASCII,x,y) */
  224.   GLUTvisibilityCB visibility;  /* visibility callback */
  225.   GLUTspecialCB special;  /* special key callback */
  226.   GLUTbuttonBoxCB buttonBox;  /* button box callback */
  227.   GLUTdialsCB dials;    /* dials callback */
  228.   GLUTspaceMotionCB spaceMotion;  /* Spaceball motion callback */
  229.   GLUTspaceRotateCB spaceRotate;  /* Spaceball rotate callback */
  230.   GLUTspaceButtonCB spaceButton;  /* Spaceball button callback */
  231.   GLUTtabletMotionCB tabletMotion;  /* tablet motion callback */
  232.   GLUTtabletButtonCB tabletButton;  /* tablet button callback */
  233. #ifdef SUPPORT_FORTRAN
  234.   /* Special Fortran display callback unneeded since no
  235.      parameters! */
  236.   GLUTreshapeFCB freshape;  /* Fortran reshape callback */
  237.   GLUTmouseFCB fmouse;  /* Fortran mouse callback */
  238.   GLUTmotionFCB fmotion;  /* Fortran motion callback */
  239.   GLUTpassiveFCB fpassive;  /* Fortran passive callback */
  240.   GLUTentryFCB fentry;  /* Fortran entry callback */
  241.   GLUTkeyboardFCB fkeyboard;  /* Fortran keyboard callback */
  242.   GLUTvisibilityFCB fvisibility;  /* Fortran visibility
  243.                                      callback */
  244.   GLUTspecialFCB fspecial;  /* special key callback */
  245.   GLUTbuttonBoxFCB fbuttonBox;  /* button box callback */
  246.   GLUTdialsFCB fdials;  /* dials callback */
  247.   GLUTspaceMotionFCB fspaceMotion;  /* Spaceball motion
  248.                                        callback */
  249.   GLUTspaceRotateFCB fspaceRotate;  /* Spaceball rotate
  250.                                        callback */
  251.   GLUTspaceButtonFCB fspaceButton;  /* Spaceball button
  252.                                        callback */
  253.   GLUTtabletMotionFCB ftabletMotion;  /* tablet motion callback 
  254.  
  255.                                        */
  256.   GLUTtabletButtonFCB ftabletButton;  /* tablet button callback 
  257.  
  258.                                        */
  259. #endif
  260. };
  261. struct _GLUToverlay {
  262.   Window win;
  263.   GLXContext ctx;
  264.   XVisualInfo *vis;     /* visual for window */
  265.   Colormap cmap;        /* RGB colormap for window; None if CI */
  266.   GLUTcolormap *colormap;  /* colormap; NULL if RGBA */
  267.   int shownState;       /* if overlay window mapped */
  268.   Bool fakeSingle;      /* faking single buffer with double */
  269.   Bool isDirect;        /* if direct context */
  270.   int damaged;          /* is layer damaged by expose? */
  271.   int transparentPixel; /* transparent pixel value */
  272.   GLUTdisplayCB display;  /* redraw callback */
  273.   /* Special Fortran display callback unneeded since no
  274.      parameters! */
  275. };
  276. typedef struct _GLUTstale GLUTstale;
  277. struct _GLUTstale {
  278.   GLUTwindow *window;
  279.   Window win;
  280.   GLUTstale *next;
  281. };
  282.  
  283. extern GLUTstale *__glutStaleWindowList;
  284. #define GLUT_OVERLAY_EVENT_FILTER_MASK \
  285.   (ExposureMask | \
  286.   StructureNotifyMask | \
  287.   EnterWindowMask | \
  288.   LeaveWindowMask)
  289. #define GLUT_DONT_PROPAGATE_FILTER_MASK \
  290.   (ButtonReleaseMask | \
  291.   ButtonPressMask | \
  292.   KeyPressMask | \
  293.   KeyReleaseMask | \
  294.   PointerMotionMask | \
  295.   Button1MotionMask | \
  296.   Button2MotionMask | \
  297.   Button3MotionMask)
  298. #define GLUT_HACK_STOP_PROPAGATE_MASK \
  299.   (KeyPressMask | \
  300.   KeyReleaseMask)
  301. typedef struct _GLUTmenu GLUTmenu;
  302. typedef struct _GLUTmenuItem GLUTmenuItem;
  303. struct _GLUTmenu {
  304.   int id;               /* small integer menu id (0-based) */
  305.   Window win;           /* X window for the menu */
  306.   GLUTselectCB select;  /* callback function of menu */
  307.   GLUTmenuItem *list;   /* list of menu entries */
  308.   int num;              /* number of entries */
  309.   Bool managed;         /* are the InputOnly windows size
  310.                            validated? */
  311.   int pixwidth;         /* width of menu in pixels */
  312.   int pixheight;        /* height of menu in pixels */
  313.   int submenus;         /* number of submenu entries */
  314.   GLUTmenuItem *highlighted;  /* pointer to highlighted menu
  315.                                  entry, NULL not highlighted */
  316.   GLUTmenu *cascade;    /* currently cascading this menu  */
  317.   GLUTmenuItem *anchor; /* currently anchored to this entry */
  318.   int x;                /* current x origin relative to the
  319.                            root window */
  320.   int y;                /* current y origin relative to the
  321.                            root window */
  322. #ifdef SUPPORT_FORTRAN
  323.   GLUTselectFCB fselect;  /* callback function of menu */
  324. #endif
  325. };
  326. struct _GLUTmenuItem {
  327.   Window win;           /* InputOnly X window for entry */
  328.   GLUTmenu *menu;       /* menu entry belongs to */
  329.   Bool isTrigger;       /* is a submenu trigger? */
  330.   int value;            /* value to return for selecting this
  331.                            entry; doubles as submenu id
  332.                            (0-base) if submenu trigger */
  333.   char *label;          /* strdup'ed label string */
  334.   int len;              /* length of label string */
  335.   int pixwidth;         /* width of X window in pixels */
  336.   GLUTmenuItem *next;   /* next menu entry on list for menu */
  337. };
  338. typedef struct _GLUTtimer GLUTtimer;
  339. struct _GLUTtimer {
  340.   GLUTtimer *next;      /* list of timers */
  341.   struct timeval timeout;  /* time to be called */
  342.   GLUTtimerCB func;     /* timer callback (value) */
  343.   int value;            /* callback return value */
  344. #ifdef SUPPORT_FORTRAN
  345.   GLUTtimerFCB ffunc;   /* Fortran timer callback */
  346. #endif
  347. };
  348. typedef struct _GLUTeventParser GLUTeventParser;
  349. struct _GLUTeventParser {
  350.   int (*func) (XEvent *);
  351.   GLUTeventParser *next;
  352. };
  353. /* Declarations to implement glutFullScreen support with
  354.    mwm/4Dwm. */
  355.  
  356. /* The following X property format is defined in Motif 1.1's
  357.    Xm/MwmUtils.h, but GLUT should not depend on that header
  358.    file. Note: Motif 1.2 expanded this structure with
  359.    uninteresting fields (to GLUT) so just stick with the
  360.    smaller Motif 1.1 structure. */
  361. typedef struct {
  362. #define MWM_HINTS_DECORATIONS   2
  363.   long flags;
  364.   long functions;
  365.   long decorations;
  366.   long input_mode;
  367. } MotifWmHints;
  368. /* private variables from glut_event.c */
  369. extern GLUTwindow *__glutWindowWorkList;
  370. extern int __glutWindowDamaged;
  371. #ifdef SUPPORT_FORTRAN
  372. extern GLUTtimer *__glutTimerList;
  373. extern GLUTtimer *__glutNewTimer;
  374. #endif
  375.  
  376. /* private variables from glut_init.c */
  377. extern Atom __glutWMDeleteWindow;
  378. extern Display *__glutDisplay;
  379. extern unsigned int __glutDisplayMode;
  380. extern GLboolean __glutDebug;
  381. extern GLboolean __glutForceDirect;
  382. extern GLboolean __glutIconic;
  383. extern GLboolean __glutTryDirect;
  384. extern Window __glutRoot;
  385. extern XSizeHints __glutSizeHints;
  386. extern char **__glutArgv;
  387. extern char *__glutProgramName;
  388. extern int __glutArgc;
  389. extern int __glutConnectionFD;
  390. extern int __glutInitHeight;
  391. extern int __glutInitWidth;
  392. extern int __glutInitX;
  393. extern int __glutInitY;
  394. extern int __glutScreen;
  395. extern int __glutScreenHeight;
  396. extern int __glutScreenWidth;
  397. extern Atom __glutMotifHints;
  398. extern unsigned int __glutModifierMask;
  399.  
  400. /* private variables from glut_menu.c */
  401. extern GLUTmenu *__glutCurrentMenu;
  402. extern GLUTmenuItem *__glutItemSelected;
  403. extern GLUTmenu *__glutMappedMenu;
  404. extern GLUTwindow *__glutMenuWindow;
  405. extern void (*__glutMenuStatusFunc) (int, int, int);
  406.  
  407. /* private variables from glut_win.c */
  408. extern GLUTwindow **__glutWindowList;
  409. extern GLUTwindow *__glutCurrentWindow;
  410. extern int __glutWindowListSize;
  411. extern void (*__glutFreeOverlayFunc) (GLUToverlay *);
  412.  
  413. /* private routines from glut_cindex.c */
  414. extern GLUTcolormap *__glutAssociateColormap(XVisualInfo * vis);
  415. extern void __glutFreeColormap(GLUTcolormap *);
  416.  
  417. /* private routines from glut_event.c */
  418. extern void (*__glutUpdateInputDeviceMaskFunc) (GLUTwindow *);
  419. extern void __glutPutOnWorkList(GLUTwindow * window,
  420.   int work_mask);
  421. extern void __glutRegisterEventParser(GLUTeventParser * parser);
  422. extern void __glutPostRedisplay(GLUTwindow * window, int layerMask);
  423.  
  424. /* private routines from glut_init.c */
  425. extern void __glutOpenXConnection(char *display);
  426. extern void __glutInitTime(struct timeval *beginning);
  427.  
  428. /* private routines for glut_menu.c */
  429. extern GLUTmenu *__glutGetMenu(Window win);
  430. extern GLUTmenu *__glutGetMenuByNum(int menunum);
  431. extern GLUTmenuItem *__glutGetMenuItem(GLUTmenu * menu,
  432.   Window win, int *which);
  433. extern void __glutFinishMenu(Window win, int x, int y);
  434. extern void __glutMenuItemEnterOrLeave(GLUTmenuItem * item,
  435.   int num, int type);
  436. extern void __glutPaintMenu(GLUTmenu * menu);
  437. extern void __glutSetMenu(GLUTmenu * menu);
  438. extern void __glutStartMenu(GLUTmenu * menu,
  439.   GLUTwindow * window, int x, int y, int x_win, int y_win);
  440.  
  441. /* private routines from glut_util.c */
  442. extern void __glutWarning(char *format,...);
  443. extern void __glutFatalError(char *format,...);
  444. extern void __glutFatalUsage(char *format,...);
  445.  
  446. /* private routines from glut_win.c */
  447. extern GLUTwindow *__glutGetWindow(Window win);
  448. extern GLUTwindow *__glutToplevelOf(GLUTwindow * window);
  449. extern void __glutChangeWindowEventMask(long mask, Bool add);
  450. extern void __glutEstablishColormapsProperty(
  451.   GLUTwindow * window);
  452. extern XVisualInfo *__glutDetermineVisual(
  453.   unsigned int mode,
  454.   Bool * fakeSingle,
  455.   XVisualInfo * (getVisualInfo) (unsigned int));
  456. extern XVisualInfo *__glutGetVisualInfo(unsigned int mode);
  457. extern void __glutSetWindow(GLUTwindow * window);
  458. extern void __glutReshapeFunc(GLUTreshapeCB reshapeFunc,
  459.   int callingConvention);
  460. extern void __glutDefaultReshape(int, int);
  461. extern void __glutSetupColormap(
  462.   XVisualInfo * vi,
  463.   GLUTcolormap ** colormap,
  464.   Colormap * cmap);
  465.  
  466. /* private routines from glut_ext.c */
  467. extern int __glutIsSupportedByGLX(char *);
  468.  
  469. /* private routines from glut_input.c */
  470. extern void __glutUpdateInputDeviceMask(GLUTwindow * window);
  471.  
  472. #endif /* __glutint_h__ */
  473.